diff -rc2N groff-1.05/Makefile groff-1.05.atari/Makefile
*** groff-1.05/Makefile	Sat May  9 15:42:02 1992
--- groff-1.05.atari/Makefile	Sat May  9 22:48:08 1992
***************
*** 1,5 ****
  #Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
  #     Written by James Clark (jjc@jclark.com)
- #
  #This file is part of groff.
  #
--- 1,4 ----
***************
*** 123,130 ****
  
  # Uncomment the next line if you have vfork().
! D2=#-DHAVE_VFORK
  
  # Uncomment the next line if you have sys_siglist[].
! D3=#-DHAVE_SYS_SIGLIST
  
  # Uncomment the next line if you have the mmap() system call (and you
--- 122,129 ----
  
  # Uncomment the next line if you have vfork().
! D2=-DHAVE_VFORK
  
  # Uncomment the next line if you have sys_siglist[].
! D3=-DHAVE_SYS_SIGLIST
  
  # Uncomment the next line if you have the mmap() system call (and you
***************
*** 133,137 ****
  
  # Uncomment the next line if you have the rename() system call.
! D5=#-DHAVE_RENAME
  
  # Uncomment the next line if the argument to localtime() is a long*
--- 132,136 ----
  
  # Uncomment the next line if you have the rename() system call.
! D5=-DHAVE_RENAME
  
  # Uncomment the next line if the argument to localtime() is a long*
***************
*** 141,145 ****
  # Uncomment the next line if wait is declared by your C++ header files
  # to take an argument of type union wait *.
! D7=#-DHAVE_UNION_WAIT
  
  # Uncoment the next line if your C++ header files declare a type pid_t
--- 140,144 ----
  # Uncomment the next line if wait is declared by your C++ header files
  # to take an argument of type union wait *.
! D7=-DHAVE_UNION_WAIT
  
  # Uncoment the next line if your C++ header files declare a type pid_t
***************
*** 155,159 ****
  # Uncomment the next line if <sys/wait.h> should not be included
  # when using wait().  Use this with the libg++ header files.
! D10=-DNO_SYS_WAIT_H
  
  # Uncomment the next line if you C++ compiler requires delete [n] rather
--- 154,158 ----
  # Uncomment the next line if <sys/wait.h> should not be included
  # when using wait().  Use this with the libg++ header files.
! D10=#-DNO_SYS_WAIT_H
  
  # Uncomment the next line if you C++ compiler requires delete [n] rather
***************
*** 185,189 ****
  # MALLOCFLAGS=-DUSG
  # Use this with SunOS 4.1 and 4.1.1.
! MALLOCFLAGS=-DBSD -DSUNOS_LOCALTIME_BUG
  
  # Comment this out if the GNU malloc gives you problems, or if you would
--- 184,189 ----
  # MALLOCFLAGS=-DUSG
  # Use this with SunOS 4.1 and 4.1.1.
! #MALLOCFLAGS=-DBSD -DSUNOS_LOCALTIME_BUG
! MALLOCFLAGS=-DBSD
  
  # Comment this out if the GNU malloc gives you problems, or if you would
***************
*** 211,217 ****
  
  # CC is the C++ compiler
! CC=g++
  # This is the flag that tells the C++ compiler to treat a .c file as C++.
! C++LANG_FLAG=
  # I'm told that -fno-inline is needed on a 68030-based Apollo
  # CC=g++ -fno-inline
--- 211,217 ----
  
  # CC is the C++ compiler
! # CC=g++
  # This is the flag that tells the C++ compiler to treat a .c file as C++.
! # C++LANG_FLAG=
  # I'm told that -fno-inline is needed on a 68030-based Apollo
  # CC=g++ -fno-inline
***************
*** 218,223 ****
  
  # Use this with gcc/g++ version 2.
! # CC=gcc
! # C++LANG_FLAG=-xc++
  
  # OLDCC is the C compiler.
--- 218,223 ----
  
  # Use this with gcc/g++ version 2.
! CC=gcc
! C++LANG_FLAG=-xc++
  
  # OLDCC is the C compiler.
***************
*** 225,231 ****
  
  PROFILE_FLAG=
! DEBUG_FLAG=-g
  # With gcc/g++ 2.0 on a sparc, -O works better than -O2.
! OPTIMIZE_FLAG=-O
  WARNING_FLAGS=#-Wall -Wcast-qual -Wwrite-strings
  
--- 225,232 ----
  
  PROFILE_FLAG=
! DEBUG_FLAG=
  # With gcc/g++ 2.0 on a sparc, -O works better than -O2.
! #OPTIMIZE_FLAG=-O
! OPTIMIZE_FLAG=-O2
  WARNING_FLAGS=#-Wall -Wcast-qual -Wwrite-strings
  
***************
*** 245,253 ****
  LDFLAGS=$(PROFILE_FLAG) $(DEBUG_FLAG) $(XLDFLAGS)
  # Libraries needed for linking C++ programs.
! LIBS=
  # Libraries needed for linking C++ programs that use libm.a.
! MLIBS=$(LIBS) -lm
  
! AR=ar
  
  # Define RANLIB to be empty if you don't have ranlib.
--- 246,255 ----
  LDFLAGS=$(PROFILE_FLAG) $(DEBUG_FLAG) $(XLDFLAGS)
  # Libraries needed for linking C++ programs.
! LIBS=-lg++
  # Libraries needed for linking C++ programs that use libm.a.
! #MLIBS=$(LIBS) -lm
! MLIBS=$(LIBS) 
  
! AR=gcc-ar
  
  # Define RANLIB to be empty if you don't have ranlib.
Binary files groff-1.05/gendef and groff-1.05.atari/gendef differ
diff -rc2N groff-1.05/groff.c groff-1.05.atari/groff.c
*** groff-1.05/groff.c	Wed Oct 30 12:12:48 1991
--- groff-1.05.atari/groff.c	Sat May  9 22:24:26 1992
***************
*** 45,50 ****
  #else
  typedef int PID_T;
! #endif
! 
  #ifdef HAVE_UNION_WAIT
  typedef union wait WAIT_STATUS_T;
--- 45,49 ----
  #else
  typedef int PID_T;
! #endif // HAVE_PID_T
  #ifdef HAVE_UNION_WAIT
  typedef union wait WAIT_STATUS_T;
diff -rc2N groff-1.05/lib/Makefile groff-1.05.atari/lib/Makefile
*** groff-1.05/lib/Makefile	Thu Aug 22 12:32:00 1991
--- groff-1.05.atari/lib/Makefile	Sat May  9 20:24:40 1992
***************
*** 34,38 ****
  	ptable.o font.o fontfile.o nametoindex.o filename.o lineno.o \
  	progname.o lf.o change_lf.o version.o tmpfile.o \
! 	$(FMOD) $(STRTOL) $(GETCWD)
  SOURCES=new.c itoa.c strerror.c error.c errarg.c fatal.c prime.c \
  	strsave.c matherr.c fmod.c assert.c iftoa.c tmpfile.c getcwd.c \
--- 34,39 ----
  	ptable.o font.o fontfile.o nametoindex.o filename.o lineno.o \
  	progname.o lf.o change_lf.o version.o tmpfile.o \
! 	$(FMOD) $(STRTOL) $(GETCWD) getopt.o getopt1.o
! 
  SOURCES=new.c itoa.c strerror.c error.c errarg.c fatal.c prime.c \
  	strsave.c matherr.c fmod.c assert.c iftoa.c tmpfile.c getcwd.c \
***************
*** 39,42 ****
--- 40,44 ----
          string.c cset.c cmap.c ptable.c font.c fontfile.c nametoindex.c \
          filename.c lineno.c progname.c lf.c change_lf.c version.c \
+ 	getopt.c getopt1.o getopt.h \
  	assert.h cset.h cmap.h errarg.h error.h font.h getpagesize.h \
  	lib.h ptable.h stringclass.h
***************
*** 55,58 ****
--- 57,66 ----
  	@echo const char \*version_string = \"`cat ../VERSION`\"\; >$@
  
+ getopt.o: getopt.c getopt.h
+ 	$(OLDCC) $(OLDCFLAGS) -c getopt.c
+ 
+ getopt1.o: getopt1.c getopt.h
+ 	$(OLDCC) $(OLDCFLAGS) -c getopt1.c
+ 
  malloc.o: malloc.c getpagesize.h
  	$(OLDCC) $(OLDCFLAGS) $(MALLOCFLAGS) -c malloc.c
***************
*** 84,88 ****
  tmpfile.o: lib.h errarg.h error.h
  
! fontpath.h: FORCE
  	@$(SHELL) ../gendef $@ "FONTPATH=\"$(FONTPATH)\""
  
--- 92,98 ----
  tmpfile.o: lib.h errarg.h error.h
  
! #fontpath.h: FORCE
! #	@$(SHELL) ../gendef $@ "FONTPATH=\"$(FONTPATH)\""
! fontpath.h: 
  	@$(SHELL) ../gendef $@ "FONTPATH=\"$(FONTPATH)\""
  
diff -rc2N groff-1.05/lib/getopt.c groff-1.05.atari/lib/getopt.c
*** groff-1.05/lib/getopt.c
--- groff-1.05.atari/lib/getopt.c	Sat May  9 19:25:24 1992
***************
*** 0 ****
--- 1,595 ----
+ /* Getopt for GNU.
+    Copyright (C) 1987, 1989, 1990 Free Software Foundation, Inc.
+ 
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+ 
+ #ifdef __STDC__
+ #define CONST const
+ #else
+ #define CONST
+ #endif
+ 
+ /* This version of `getopt' appears to the caller like standard Unix `getopt'
+    but it behaves differently for the user, since it allows the user
+    to intersperse the options with the other arguments.
+ 
+    As `getopt' works, it permutes the elements of `argv' so that,
+    when it is done, all the options precede everything else.  Thus
+    all application programs are extended to handle flexible argument order.
+ 
+    Setting the environment variable _POSIX_OPTION_ORDER disables permutation.
+    Then the behavior is completely standard.
+ 
+    GNU application programs can use a third alternative mode in which
+    they can distinguish the relative order of options and other arguments.  */
+ 
+ #include <stdio.h>
+ 
+ /* If compiled with GNU C, use the built-in alloca */
+ #ifdef __GNUC__
+ #define alloca __builtin_alloca
+ #else /* not __GNUC__ */
+ #ifdef sparc
+ #include <alloca.h>
+ #else
+ char *alloca ();
+ #endif
+ #endif /* not __GNUC__ */
+ 
+ #if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__)
+ #include <stdlib.h>
+ #include <string.h>
+ #define bcopy(s, d, n) memcpy ((d), (s), (n))
+ #define index strchr
+ #else
+ 
+ #ifdef USG
+ #include <string.h>
+ #define bcopy(s, d, n) memcpy ((d), (s), (n))
+ #define index strchr
+ #else
+ #ifdef VMS
+ #include <string.h>
+ #else
+ #include <strings.h>
+ #endif
+ void bcopy ();
+ #endif
+ 
+ char *getenv ();
+ char *malloc ();
+ #endif
+ 
+ /* For communication from `getopt' to the caller.
+    When `getopt' finds an option that takes an argument,
+    the argument value is returned here.
+    Also, when `ordering' is RETURN_IN_ORDER,
+    each non-option ARGV-element is returned here.  */
+ 
+ char *optarg = 0;
+ 
+ /* Index in ARGV of the next element to be scanned.
+    This is used for communication to and from the caller
+    and for communication between successive calls to `getopt'.
+ 
+    On entry to `getopt', zero means this is the first call; initialize.
+ 
+    When `getopt' returns EOF, this is the index of the first of the
+    non-option elements that the caller should itself scan.
+ 
+    Otherwise, `optind' communicates from one call to the next
+    how much of ARGV has been scanned so far.  */
+ 
+ int optind = 0;
+ 
+ /* The next char to be scanned in the option-element
+    in which the last option character we returned was found.
+    This allows us to pick up the scan where we left off.
+ 
+    If this is zero, or a null string, it means resume the scan
+    by advancing to the next ARGV-element.  */
+ 
+ static char *nextchar;
+ 
+ /* Callers store zero here to inhibit the error message
+    for unrecognized options.  */
+ 
+ int opterr = 1;
+ 
+ /* Describe how to deal with options that follow non-option ARGV-elements.
+ 
+    If the caller did not specify anything,
+    the default is REQUIRE_ORDER if the environment variable
+    _POSIX_OPTION_ORDER is defined, PERMUTE otherwise.
+ 
+    REQUIRE_ORDER means don't recognize them as options;
+    stop option processing when the first non-option is seen.
+    This is what Unix does.
+    This mode of operation is selected by either setting the environment
+    variable _POSIX_OPTION_ORDER, or using `+' as the first character
+    of the list of option characters.
+ 
+    PERMUTE is the default.  We permute the contents of ARGV as we scan,
+    so that eventually all the non-options are at the end.  This allows options
+    to be given in any order, even with programs that were not written to
+    expect this.
+ 
+    RETURN_IN_ORDER is an option available to programs that were written
+    to expect options and other ARGV-elements in any order and that care about
+    the ordering of the two.  We describe each non-option ARGV-element
+    as if it were the argument of an option with character code 1.
+    Using `-' as the first character of the list of option characters
+    selects this mode of operation.
+ 
+    The special argument `--' forces an end of option-scanning regardless
+    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+    `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
+ 
+ static enum
+ {
+   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+ } ordering;
+ 
+ /* Describe the long-named options requested by the application.
+    _GETOPT_LONG_OPTIONS is a vector of `struct option' terminated by an
+    element containing a name which is zero.
+    The field `has_arg' is 1 if the option takes an argument,
+    2 if it takes an optional argument.  */
+ 
+ struct option
+ {
+   char *name;
+   int has_arg;
+   int *flag;
+   int val;
+ };
+ 
+ CONST struct option *_getopt_long_options;
+ 
+ int _getopt_long_only = 0;
+ 
+ /* Index in _GETOPT_LONG_OPTIONS of the long-named option actually found.
+    Only valid when a long-named option was found. */
+ 
+ int option_index;
+ 
+ /* Handle permutation of arguments.  */
+ 
+ /* Describe the part of ARGV that contains non-options that have
+    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+    `last_nonopt' is the index after the last of them.  */
+ 
+ static int first_nonopt;
+ static int last_nonopt;
+ 
+ /* Exchange two adjacent subsequences of ARGV.
+    One subsequence is elements [first_nonopt,last_nonopt)
+     which contains all the non-options that have been skipped so far.
+    The other is elements [last_nonopt,optind), which contains all
+     the options processed since those non-options were skipped.
+ 
+    `first_nonopt' and `last_nonopt' are relocated so that they describe
+     the new indices of the non-options in ARGV after they are moved.  */
+ 
+ static void
+ exchange (argv)
+      char **argv;
+ {
+   int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
+   char **temp = (char **) alloca (nonopts_size);
+ 
+   /* Interchange the two blocks of data in ARGV.  */
+ 
+   bcopy (&argv[first_nonopt], temp, nonopts_size);
+   bcopy (&argv[last_nonopt], &argv[first_nonopt],
+ 	 (optind - last_nonopt) * sizeof (char *));
+   bcopy (temp, &argv[first_nonopt + optind - last_nonopt], nonopts_size);
+ 
+   /* Update records for the slots the non-options now occupy.  */
+ 
+   first_nonopt += (optind - last_nonopt);
+   last_nonopt = optind;
+ }
+ 
+ /* Scan elements of ARGV (whose length is ARGC) for option characters
+    given in OPTSTRING.
+ 
+    If an element of ARGV starts with '-', and is not exactly "-" or "--",
+    then it is an option element.  The characters of this element
+    (aside from the initial '-') are option characters.  If `getopt'
+    is called repeatedly, it returns successively each of the option characters
+    from each of the option elements.
+ 
+    If `getopt' finds another option character, it returns that character,
+    updating `optind' and `nextchar' so that the next call to `getopt' can
+    resume the scan with the following option character or ARGV-element.
+ 
+    If there are no more option characters, `getopt' returns `EOF'.
+    Then `optind' is the index in ARGV of the first ARGV-element
+    that is not an option.  (The ARGV-elements have been permuted
+    so that those that are not options now come last.)
+ 
+    OPTSTRING is a string containing the legitimate option characters.
+    If an option character is seen that is not listed in OPTSTRING,
+    return '?' after printing an error message.  If you set `opterr' to
+    zero, the error message is suppressed but we still return '?'.
+ 
+    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+    so the following text in the same ARGV-element, or the text of the following
+    ARGV-element, is returned in `optarg'.  Two colons mean an option that
+    wants an optional arg; if there is text in the current ARGV-element,
+    it is returned in `optarg', otherwise `optarg' is set to zero.
+ 
+    If OPTSTRING starts with `-' or `+', it requests different methods of
+    handling the non-option ARGV-elements.
+    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+ 
+    Long-named options begin with `+' instead of `-'.
+    Their names may be abbreviated as long as the abbreviation is unique
+    or is an exact match for some defined option.  If they have an
+    argument, it follows the option name in the same ARGV-element, separated
+    from the option name by a `=', or else the in next ARGV-element.
+    When `getopt' finds a long-named option, it returns 0 if that option's
+    `flag' field is nonzero, the value of the option's `val' field
+    otherwise.  */
+ 
+ int
+ getopt (argc, argv, optstring)
+      int argc;
+      char **argv;
+      CONST char *optstring;
+ {
+   optarg = 0;
+ 
+   /* Initialize the internal data when the first call is made.
+      Start processing options with ARGV-element 1 (since ARGV-element 0
+      is the program name); the sequence of previously skipped
+      non-option ARGV-elements is empty.  */
+ 
+   if (optind == 0)
+     {
+       first_nonopt = last_nonopt = optind = 1;
+ 
+       nextchar = 0;
+ 
+       /* Determine how to handle the ordering of options and nonoptions.  */
+ 
+       if (optstring[0] == '-')
+ 	{
+ 	  ordering = RETURN_IN_ORDER;
+ 	  ++optstring;
+ 	}
+       else if (optstring[0] == '+')
+ 	{
+ 	  ordering = REQUIRE_ORDER;
+ 	  ++optstring;
+ 	}
+       else if (getenv ("_POSIX_OPTION_ORDER") != 0)
+ 	ordering = REQUIRE_ORDER;
+       else
+ 	ordering = PERMUTE;
+     }
+ 
+   if (nextchar == 0 || *nextchar == 0)
+     {
+       if (ordering == PERMUTE)
+ 	{
+ 	  /* If we have just processed some options following some non-options,
+ 	     exchange them so that the options come first.  */
+ 
+ 	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+ 	    exchange (argv);
+ 	  else if (last_nonopt != optind)
+ 	    first_nonopt = optind;
+ 
+ 	  /* Now skip any additional non-options
+ 	     and extend the range of non-options previously skipped.  */
+ 
+ 	  while (optind < argc
+ 		 && (argv[optind][0] != '-'
+ 		     || argv[optind][1] == 0)
+ 		 && (_getopt_long_options == 0
+ 		     || argv[optind][0] != '+'
+ 		     || argv[optind][1] == 0))
+ 	    optind++;
+ 	  last_nonopt = optind;
+ 	}
+ 
+       /* Special ARGV-element `--' means premature end of options.
+ 	 Skip it like a null option,
+ 	 then exchange with previous non-options as if it were an option,
+ 	 then skip everything else like a non-option.  */
+ 
+       if (optind != argc && !strcmp (argv[optind], "--"))
+ 	{
+ 	  optind++;
+ 
+ 	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+ 	    exchange (argv);
+ 	  else if (first_nonopt == last_nonopt)
+ 	    first_nonopt = optind;
+ 	  last_nonopt = argc;
+ 
+ 	  optind = argc;
+ 	}
+ 
+       /* If we have done all the ARGV-elements, stop the scan
+ 	 and back over any non-options that we skipped and permuted.  */
+ 
+       if (optind == argc)
+ 	{
+ 	  /* Set the next-arg-index to point at the non-options
+ 	     that we previously skipped, so the caller will digest them.  */
+ 	  if (first_nonopt != last_nonopt)
+ 	    optind = first_nonopt;
+ 	  return EOF;
+ 	}
+ 
+       /* If we have come to a non-option and did not permute it,
+ 	 either stop the scan or describe it to the caller and pass it by.  */
+ 
+       if ((argv[optind][0] != '-' || argv[optind][1] == 0)
+ 	  && (_getopt_long_options == 0
+ 	      || argv[optind][0] != '+' || argv[optind][1] == 0))
+ 	{
+ 	  if (ordering == REQUIRE_ORDER)
+ 	    return EOF;
+ 	  optarg = argv[optind++];
+ 	  return 1;
+ 	}
+ 
+       /* We have found another option-ARGV-element.
+ 	 Start decoding its characters.  */
+ 
+       nextchar = argv[optind] + 1;
+     }
+ 
+   if (_getopt_long_options != 0
+       && (argv[optind][0] == '+'
+ 	  || (_getopt_long_only && argv[optind][0] == '-'))
+     )
+     {
+       CONST struct option *p;
+       char *s = nextchar;
+       int exact = 0;
+       int ambig = 0;
+       CONST struct option *pfound = 0;
+       int indfound;
+ 
+       while (*s && *s != '=')
+ 	s++;
+ 
+       /* Test all options for either exact match or abbreviated matches.  */
+       for (p = _getopt_long_options, option_index = 0; p->name;
+ 	   p++, option_index++)
+ 	if (!strncmp (p->name, nextchar, s - nextchar))
+ 	  {
+ 	    if (s - nextchar == strlen (p->name))
+ 	      {
+ 		/* Exact match found.  */
+ 		pfound = p;
+ 		indfound = option_index;
+ 		exact = 1;
+ 		break;
+ 	      }
+ 	    else if (pfound == 0)
+ 	      {
+ 		/* First nonexact match found.  */
+ 		pfound = p;
+ 		indfound = option_index;
+ 	      }
+ 	    else
+ 	      /* Second nonexact match found.  */
+ 	      ambig = 1;
+ 	  }
+ 
+       if (ambig && !exact)
+ 	{
+ 	  fprintf (stderr, "%s: option `%s' is ambiguous\n",
+ 		   argv[0], argv[optind]);
+ 	  nextchar += strlen (nextchar);
+ 	  optind++;
+ 	  return '?';
+ 	}
+ 
+       if (pfound != 0)
+ 	{
+ 	  option_index = indfound;
+ 	  optind++;
+ 	  if (*s)
+ 	    {
+ 	      if (pfound->has_arg > 0)
+ 		optarg = s + 1;
+ 	      else
+ 		{
+ 		  fprintf (stderr,
+ 			   "%s: option `%c%s' doesn't allow an argument\n",
+ 			   argv[0], argv[optind - 1][0], pfound->name);
+ 		  nextchar += strlen (nextchar);
+ 		  return '?';
+ 		}
+ 	    }
+ 	  else if (pfound->has_arg == 1)
+ 	    {
+ 	      if (optind < argc)
+ 		optarg = argv[optind++];
+ 	      else
+ 		{
+ 		  fprintf (stderr, "%s: option `%s' requires an argument\n",
+ 			   argv[0], argv[optind - 1]);
+ 		  nextchar += strlen (nextchar);
+ 		  return '?';
+ 		}
+ 	    }
+ 	  nextchar += strlen (nextchar);
+ 	  if (pfound->flag)
+ 	    {
+ 	      *(pfound->flag) = pfound->val;
+ 	      return 0;
+ 	    }
+ 	  return pfound->val;
+ 	}
+       /* Can't find it as a long option.  If this is getopt_long_only,
+ 	 and the option starts with '-' and is a valid short
+ 	 option, then interpret it as a short option.  Otherwise it's
+ 	 an error.  */
+       if (_getopt_long_only == 0 || argv[optind][0] == '+' ||
+ 	  index (optstring, *nextchar) == 0)
+ 	{
+ 	  if (opterr != 0)
+ 	    fprintf (stderr, "%s: unrecognized option `%c%s'\n",
+ 		     argv[0], argv[optind][0], nextchar);
+ 	  nextchar += strlen (nextchar);
+ 	  optind++;
+ 	  return '?';
+ 	}
+     }
+ 
+   /* Look at and handle the next option-character.  */
+ 
+   {
+     char c = *nextchar++;
+     char *temp = index (optstring, c);
+ 
+     /* Increment `optind' when we start to process its last character.  */
+     if (*nextchar == 0)
+       optind++;
+ 
+     if (temp == 0 || c == ':')
+       {
+ 	if (opterr != 0)
+ 	  {
+ 	    if (c < 040 || c >= 0177)
+ 	      fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
+ 		       argv[0], c);
+ 	    else
+ 	      fprintf (stderr, "%s: unrecognized option `-%c'\n",
+ 		       argv[0], c);
+ 	  }
+ 	return '?';
+       }
+     if (temp[1] == ':')
+       {
+ 	if (temp[2] == ':')
+ 	  {
+ 	    /* This is an option that accepts an argument optionally.  */
+ 	    if (*nextchar != 0)
+ 	      {
+ 		optarg = nextchar;
+ 		optind++;
+ 	      }
+ 	    else
+ 	      optarg = 0;
+ 	    nextchar = 0;
+ 	  }
+ 	else
+ 	  {
+ 	    /* This is an option that requires an argument.  */
+ 	    if (*nextchar != 0)
+ 	      {
+ 		optarg = nextchar;
+ 		/* If we end this ARGV-element by taking the rest as an arg,
+ 		   we must advance to the next element now.  */
+ 		optind++;
+ 	      }
+ 	    else if (optind == argc)
+ 	      {
+ 		if (opterr != 0)
+ 		  fprintf (stderr, "%s: option `-%c' requires an argument\n",
+ 			   argv[0], c);
+ 		c = '?';
+ 	      }
+ 	    else
+ 	      /* We already incremented `optind' once;
+ 		 increment it again when taking next ARGV-elt as argument.  */
+ 	      optarg = argv[optind++];
+ 	    nextchar = 0;
+ 	  }
+       }
+     return c;
+   }
+ }
+ 
+ #ifdef TEST
+ 
+ /* Compile with -DTEST to make an executable for use in testing
+    the above definition of `getopt'.  */
+ 
+ int
+ main (argc, argv)
+      int argc;
+      char **argv;
+ {
+   int c;
+   int digit_optind = 0;
+ 
+   while (1)
+     {
+       int this_option_optind = optind ? optind : 1;
+ 
+       c = getopt (argc, argv, "abc:d:0123456789");
+       if (c == EOF)
+ 	break;
+ 
+       switch (c)
+ 	{
+ 	case '0':
+ 	case '1':
+ 	case '2':
+ 	case '3':
+ 	case '4':
+ 	case '5':
+ 	case '6':
+ 	case '7':
+ 	case '8':
+ 	case '9':
+ 	  if (digit_optind != 0 && digit_optind != this_option_optind)
+ 	    printf ("digits occur in two different argv-elements.\n");
+ 	  digit_optind = this_option_optind;
+ 	  printf ("option %c\n", c);
+ 	  break;
+ 
+ 	case 'a':
+ 	  printf ("option a\n");
+ 	  break;
+ 
+ 	case 'b':
+ 	  printf ("option b\n");
+ 	  break;
+ 
+ 	case 'c':
+ 	  printf ("option c with value `%s'\n", optarg);
+ 	  break;
+ 
+ 	case '?':
+ 	  break;
+ 
+ 	default:
+ 	  printf ("?? getopt returned character code 0%o ??\n", c);
+ 	}
+     }
+ 
+   if (optind < argc)
+     {
+       printf ("non-option ARGV-elements: ");
+       while (optind < argc)
+ 	printf ("%s ", argv[optind++]);
+       printf ("\n");
+     }
+ 
+   exit (0);
+ }
+ 
+ #endif /* TEST */
diff -rc2N groff-1.05/lib/getopt.h groff-1.05.atari/lib/getopt.h
*** groff-1.05/lib/getopt.h
--- groff-1.05.atari/lib/getopt.h	Sat May  9 20:42:54 1992
***************
*** 0 ****
--- 1,121 ----
+ /* declarations for getopt -- command-line argument scanning subroutine
+    Copyright 1989-1991  Free Software Foundation, Inc.
+ 
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this proggram; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+ 
+ /* For communication from `getopt' to the caller.
+    When `getopt' finds an option that takes an argument,
+    the argument value is returned here.
+    Also, when `ordering' is RETURN_IN_ORDER,
+    each non-option ARGV-element is returned here.  */
+ 
+ #ifndef __GETOPT_H
+ #define __GETOPT_H
+ 
+ #ifdef __cplusplus
+ extern "C" {
+ #endif
+ 
+ extern char *optarg;
+ 
+ /* Index in ARGV of the next element to be scanned.
+    This is used for communication to and from the caller
+    and for communication between successive calls to `getopt'.
+ 
+    On entry to `getopt', zero means this is the first call; initialize.
+ 
+    When `getopt' returns EOF, this is the index of the first of the
+    non-option elements that the caller should itself scan.
+ 
+    Otherwise, `optind' communicates from one call to the next
+    how much of ARGV has been scanned so far.  */
+ 
+ extern int optind;
+ 
+ /* Callers store zero here to inhibit the error message `getopt' prints
+    for unrecognized options.  */
+ 
+ extern int opterr;
+ 
+ /* Describe the long-named options requested by the application.
+    _GETOPT_LONG_OPTIONS is a vector of `struct option' terminated by an
+    element containing a name which is zero.
+ 
+    The field `has_arg' is:
+    0 if the option does not take an argument,
+    1 if the option requires an argument,
+    2 if the option takes an optional argument.
+ 
+    The type getopt_long_has_arg defines these values below.
+ 
+    If the field `flag' is nonzero, it points to a variable that is set
+    to the value given in the field `val' when the option is found, but
+    left unchanged if the option is not found.
+ 
+    To have a long-named option do something other than set an `int' to
+    a compiled-in constant, such as set a value from `optarg', set the
+    option's `flag' field to zero and its `val' field to a nonzero
+    value (the equivalent single-letter option character, if there is
+    one).  For long options that have a zero `flag' field, `getopt'
+    returns the contents of the `val' field.  */
+ 
+ enum getopt_long_has_arg {
+     GETOPT_NO_ARG = 0,
+     GETOPT_REQ_ARG = 1,
+     GETOPT_OPT_ARG = 2
+ };
+ 
+ struct option
+ {
+   char *name;
+   int has_arg;
+   int *flag;
+   int val;
+ };
+ 
+ #ifdef __STDC__
+ extern const struct option *_getopt_long_options;
+ #else
+ extern struct option *_getopt_long_options;
+ #endif
+ 
+ /* If nonzero, '-' can introduce long-named options.
+    Set by getopt_long_only.  */
+ 
+ extern int _getopt_long_only;
+ 
+ /* The index in GETOPT_LONG_OPTIONS of the long-named option found.
+    Only valid when a long-named option has been found by the most
+    recent call to `getopt'.  */
+ 
+ extern int option_index;
+ 
+ #ifdef __STDC__
+ int getopt (int argc, char **argv, const char *shortopts);
+ int getopt_long (int argc, char **argv, const char *shortopts,
+ 		 const struct option *longopts, int *longind);
+ int getopt_long_only (int argc, char **argv, const char *shortopts,
+ 		      const struct option *longopts, int *longind);
+ void envopt(int *pargc, char ***pargv, char *optstr);
+ #else
+ int getopt ();
+ int getopt_long ();
+ int getopt_long_only ();
+ void envopt();
+ #endif
+ #ifdef __cplusplus
+ }
+ #endif
+ #endif				/* __GETOPT_H */
diff -rc2N groff-1.05/lib/getopt1.c groff-1.05.atari/lib/getopt1.c
*** groff-1.05/lib/getopt1.c
--- groff-1.05.atari/lib/getopt1.c	Sat May  9 19:25:26 1992
***************
*** 0 ****
--- 1,160 ----
+ /* Getopt for GNU.
+    Copyright (C) 1987, 1989 Free Software Foundation, Inc.
+ 
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+ 
+ #include "getopt.h"
+ 
+ #ifdef __STDC__
+ #define CONST const
+ #else
+ #define CONST
+ #endif
+ 
+ #if !defined (NULL)
+ #define NULL 0
+ #endif
+ 
+ int
+ getopt_long (argc, argv, options, long_options, opt_index)
+      int argc;
+      char **argv;
+      CONST char *options;
+      CONST struct option *long_options;
+      int *opt_index;
+ {
+   int val;
+ 
+   _getopt_long_options = long_options;
+   val = getopt (argc, argv, options);
+   if (val == 0 && opt_index != NULL)
+     *opt_index = option_index;
+   return val;
+ }
+ 
+ /* Like getopt_long, but '-' as well as '+' can indicate a long option.
+    If an option that starts with '-' doesn't match a long option,
+    but does match a short option, it is parsed as a short option
+    instead. */
+ 
+ int 
+ getopt_long_only (argc, argv, options, long_options, opt_index)
+      int argc;
+      char **argv;
+      CONST char *options;
+      CONST struct option *long_options;
+      int *opt_index;
+ {
+   int val;
+ 
+   _getopt_long_options = long_options;
+   _getopt_long_only = 1;
+   val = getopt (argc, argv, options);
+   if (val == 0 && opt_index != NULL)
+     *opt_index = option_index;
+   return val;
+ }
+ 
+ 
+ #ifdef TEST
+ 
+ #include <stdio.h>
+ 
+ int
+ main (argc, argv)
+      int argc;
+      char **argv;
+ {
+   int c;
+   int digit_optind = 0;
+ 
+   while (1)
+     {
+       int this_option_optind = optind ? optind : 1;
+       char *name = '\0';
+       int option_index = 0;
+       static struct option long_options[] =
+       {
+ 	{"add", 1, 0, 0},
+ 	{"append", 0, 0, 0},
+ 	{"delete", 1, 0, 0},
+ 	{"verbose", 0, 0, 0},
+ 	{"create", 0, 0, 0},
+ 	{"file", 1, 0, 0},
+ 	{0, 0, 0, 0}
+       };
+ 
+       c = getopt_long (argc, argv, "abc:d:0123456789",
+ 		       long_options, &option_index);
+       if (c == EOF)
+ 	break;
+ 
+       switch (c)
+ 	{
+ 	case 0:
+ 	  printf ("option %s", (long_options[option_index]).name);
+ 	  if (optarg)
+ 	    printf (" with arg %s", optarg);
+ 	  printf ("\n");
+ 	  break;
+ 
+ 	case '0':
+ 	case '1':
+ 	case '2':
+ 	case '3':
+ 	case '4':
+ 	case '5':
+ 	case '6':
+ 	case '7':
+ 	case '8':
+ 	case '9':
+ 	  if (digit_optind != 0 && digit_optind != this_option_optind)
+ 	    printf ("digits occur in two different argv-elements.\n");
+ 	  digit_optind = this_option_optind;
+ 	  printf ("option %c\n", c);
+ 	  break;
+ 
+ 	case 'a':
+ 	  printf ("option a\n");
+ 	  break;
+ 
+ 	case 'b':
+ 	  printf ("option b\n");
+ 	  break;
+ 
+ 	case 'c':
+ 	  printf ("option c with value `%s'\n", optarg);
+ 	  break;
+ 
+ 	case '?':
+ 	  break;
+ 
+ 	default:
+ 	  printf ("?? getopt returned character code 0%o ??\n", c);
+ 	}
+     }
+ 
+   if (optind < argc)
+     {
+       printf ("non-option ARGV-elements: ");
+       while (optind < argc)
+ 	printf ("%s ", argv[optind++]);
+       printf ("\n");
+     }
+ 
+   exit (0);
+ }
+ 
+ #endif /* TEST */
diff -rc2N groff-1.05/lib/getpagesize.h groff-1.05.atari/lib/getpagesize.h
*** groff-1.05/lib/getpagesize.h	Wed Feb 21 01:35:42 1990
--- groff-1.05.atari/lib/getpagesize.h	Sat May  9 19:06:48 1992
***************
*** 1,2 ****
--- 1,5 ----
+ #ifdef atarist
+ #define getpagesize() 4096
+ #else
  #ifdef BSD
  #ifndef BSD4_1
***************
*** 21,25 ****
  #endif /* no NBPG */
  #endif /* no EXEC_PAGESIZE */
- 
  #endif /* not HAVE_GETPAGESIZE */
! 
--- 24,27 ----
  #endif /* no NBPG */
  #endif /* no EXEC_PAGESIZE */
  #endif /* not HAVE_GETPAGESIZE */
! #endif /* atarist */
diff -rc2N groff-1.05/lib/lib.h groff-1.05.atari/lib/lib.h
*** groff-1.05/lib/lib.h	Sat May  9 15:43:04 1992
--- groff-1.05.atari/lib/lib.h	Sat May  9 20:26:20 1992
***************
*** 32,35 ****
--- 32,38 ----
  int is_prime(unsigned);
  #include <stdio.h>
+ #ifdef atarist
+ #include "getopt.h"
+ #endif
  FILE *xtmpfile();
  
diff -rc2N groff-1.05/lib/strerror.c groff-1.05.atari/lib/strerror.c
*** groff-1.05/lib/strerror.c	Sat Jan 19 10:59:24 1991
--- groff-1.05.atari/lib/strerror.c	Sat May  9 19:04:24 1992
***************
*** 1,2 ****
--- 1,3 ----
+ #ifndef atarist
  /* Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
       Written by James Clark (jjc@jclark.uucp)
***************
*** 34,35 ****
--- 35,37 ----
    }
  }
+ #endif atarist
diff -rc2N groff-1.05/pic/mkpictab groff-1.05.atari/pic/mkpictab
*** groff-1.05/pic/mkpictab
--- groff-1.05.atari/pic/mkpictab	Sat May  9 23:21:28 1992
***************
*** 0 ****
--- 1 ----
+ gcc -c -I../lib -xc++ -O2 -DHAVE_VFORK -DHAVE_SYS_SIGLIST -DHAVE_RENAME -DHAVE_UNION_WAIT -DWAIT_COREDUMP_0200 pic.tab.c
diff -rc2N groff-1.05/pic/pic.y groff-1.05.atari/pic/pic.y
*** groff-1.05/pic/pic.y	Sat May  9 15:45:24 1992
--- groff-1.05.atari/pic/pic.y	Sat May  9 19:15:56 1992
***************
*** 31,34 ****
--- 31,35 ----
  extern void do_lookahead();
  
+ #if !defined(_M68881) && !defined(__M68881)
  extern "C" {
    double fmod(double, double);
***************
*** 35,38 ****
--- 36,40 ----
    int rand();
  }
+ #endif
  
  /* Maximum number of characters produced by printf("%g") */
diff -rc2N groff-1.05/ps/Makefile groff-1.05.atari/ps/Makefile
*** groff-1.05/ps/Makefile	Sat May  9 15:45:26 1992
--- groff-1.05.atari/ps/Makefile	Sat May  9 21:33:28 1992
***************
*** 55,59 ****
        ../lib/stringclass.h ../lib/cset.h
  
! broken.h: FORCE
  	@$(SHELL) ../gendef $@ "BROKEN_SPOOLER_FLAGS=$(BROKEN_SPOOLER_FLAGS)"
  
--- 55,62 ----
        ../lib/stringclass.h ../lib/cset.h
  
! #broken.h: FORCE
! #	@$(SHELL) ../gendef $@ "BROKEN_SPOOLER_FLAGS=$(BROKEN_SPOOLER_FLAGS)"
! 
! broken.h: 
  	@$(SHELL) ../gendef $@ "BROKEN_SPOOLER_FLAGS=$(BROKEN_SPOOLER_FLAGS)"
  
diff -rc2N groff-1.05/refer/indxbib.c groff-1.05.atari/refer/indxbib.c
*** groff-1.05/refer/indxbib.c	Sat May  9 15:45:50 1992
--- groff-1.05.atari/refer/indxbib.c	Sat May  9 21:25:54 1992
***************
*** 206,212 ****
--- 206,218 ----
    if (!mktemp(temp_index_file) || !temp_index_file[0])
      fatal("cannot create file name for temporary file");
+ #ifndef atarist
    signal(SIGHUP, fatal_signal);
    signal(SIGINT, fatal_signal);
    signal(SIGTERM, fatal_signal);
+ #else
+   signal(SIGHUP, (__Sigfunc) fatal_signal);
+   signal(SIGINT, (__Sigfunc) fatal_signal);
+   signal(SIGTERM,(__Sigfunc) fatal_signal);
+ #endif  
    int fd = creat(temp_index_file, 0444);
    if (fd < 0)
